Unrendered is not one thing: split prose from structure and control (#104) - #482

…104)

#480 applied `core/step_fields` to template validation and got the first half
right -- a stray brace in a `description:` no longer rejects a pipeline that
runs. It got the second half wrong by treating *every* unrendered field as
prose, so all of these compiled with nothing but a wording note:

    metadata:
      goto: "{{ nosuch }}"          # execution sent to a step named `{{ nosuch }}`
      priority: "{{ nosuch }}"      # a priority of that text
      requires_model: "{{ nosuch }}"
    tool: "{{ nosuch }}"            # a registry lookup for that text
    id: "{{ nosuch }}"

Unrendered says what does *not* happen to a field, not what the field is for.
Three cases, not one:

* **prose** -- `name`, `description`, and metadata an author wrote for
  themselves. Nothing acts on it; the braces reach a log line and the pipeline
  runs. Still a warning, because the author will not get what they typed.
* **structural** -- `id`, `tool`, `dependencies`, `depends_on`. These *name*
  things. A literal `{{ x }}` names nothing, so the pipeline is already
  broken and calling it valid says the opposite. Now an error.
* **operational metadata** -- the keys the runtime reads. Not rendered, so
  control code receives the literal template text. Now an error.

`OPERATIONAL_METADATA_KEYS` is evidence-backed rather than guessed: every key
has a runtime read cited beside it, from `goto` at `orchestrator.py:1074` to
`required_capabilities` at `core/control_system.py:130`. Keys the compiler
*writes* -- `step_type`, `retry_count`, the loop bookkeeping -- are excluded,
because an author never supplies them.

Two boundaries the split needs beyond the three sets. A reserved key counts
only at metadata's top level: `metadata.notes.priority` is somebody's data
structure, not the key the runtime reads. And step recognition is now off
entirely inside an inert subtree -- `metadata.steps` holding `for_each` and
`while` was being walked as pipeline structure and reported as an ambiguous
loop, from inside a subtree this module had just declared verbatim-copied.

Separately, `create_template_issue` hardcoded `code="template_error"`, so
every template finding arrived under one code and a consumer had to parse the
message to tell an inert-field note from a loop-scope error. The validator's
own `error_type` now flows through the compiler into the finding, which is
what the structured payload exists for.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>